{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepONet_Eikonal_airfoil.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "machine_shape": "hm"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "mRR_BT5vUnSw"
   },
   "source": [
    "import numpy as onp\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.experimental.ode import odeint\n",
    "from jax.nn import relu, elu, softplus\n",
    "from jax.config import config\n",
    "from jax.lax import while_loop, scan, cond\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import griddata\n",
    "\n",
    "from jax.flatten_util import ravel_pytree\n",
    "\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rTZSJ2taqCPZ"
   },
   "source": [
    "# Define the neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yPdIBu2xPoi4"
   },
   "source": [
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s,  mu_y = 0.0, sigma_y = 1.0,\n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u\n",
    "        self.y = y\n",
    "        self.s = s\n",
    "\n",
    "        self.mu_y = mu_y\n",
    "        self.sigma_y = sigma_y\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "      \n",
    "        u = self.u[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        s = self.s[idx,:]\n",
    "\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kbh_Vdc8VmZZ"
   },
   "source": [
    "# Define the model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=elu)\n",
    "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=elu)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=1000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        _, self.unravel_params = ravel_pytree(params)\n",
    "\n",
    "        # Logger\n",
    "        self.itercount = itertools.count()\n",
    "        self.loss_log = []\n",
    "        self.loss_bcs_log = []\n",
    "        self.loss_res_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, y1, y2):\n",
    "        y = np.stack([y1, y2])\n",
    "        branch_params, trunk_params = params\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return outputs\n",
    "      \n",
    "    # Define PDE residual\n",
    "    def residual_net(self, params, u, y1, y2):\n",
    "        s_y1 = grad(self.operator_net, argnums = 2)(params, u, y1, y2)\n",
    "        s_y2 = grad(self.operator_net, argnums = 3)(params, u, y1, y2)\n",
    "\n",
    "        res = s_y1**2 + s_y2**2\n",
    "        return res\n",
    "\n",
    "    # Define boundary loss\n",
    "    def loss_bcs(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "        # Compute loss\n",
    "        loss = np.mean((pred)**2)\n",
    "        return loss\n",
    "\n",
    "    # Define residual loss\n",
    "    def loss_res(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0, 0))(params, u, y[:,0], y[:, 1])\n",
    "        # Compute loss\n",
    "        loss = np.mean((pred - 1.0)**2)\n",
    "        return loss    \n",
    "    \n",
    "    # Define total loss\n",
    "    def loss(self, params, bcs_batch, res_batch):\n",
    "        loss_bcs = self.loss_bcs(params, bcs_batch)\n",
    "        loss_res = self.loss_res(params, res_batch)\n",
    "        loss = 100 * loss_bcs + loss_res\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, bcs_batch, res_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, bcs_batch, res_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, bcs_dataset, res_dataset, nIter = 10000):\n",
    "        bcs_data = iter(bcs_dataset)\n",
    "        res_data = iter(res_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            # Fetch data\n",
    "            bcs_batch= next(bcs_data)\n",
    "            res_batch = next(res_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, bcs_batch, res_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, bcs_batch, res_batch)\n",
    "                loss_bcs_value = self.loss_bcs(params, bcs_batch)\n",
    "                loss_res_value = self.loss_res(params, res_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_bcs_log.append(loss_bcs_value)\n",
    "                self.loss_res_log.append(loss_res_value)\n",
    "\n",
    "                # Print losses\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_bcs' : loss_bcs_value, \n",
    "                                  'loss_res': loss_res_value})\n",
    "       \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return s_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "smf3cr6VhPr3"
   },
   "source": [
    "# Load data\n",
    "datafile = 'airfoil.npy'\n",
    "data = np.load(datafile, allow_pickle=True)\n",
    "data = np.array(data)\n",
    "\n",
    "D = data.reshape(-1, 2)\n",
    "mu = D.mean(0)\n",
    "sigma = D.std(0)\n",
    "\n",
    "N_train = 1000\n",
    "P_train = data.shape[1]\n",
    "Q_train = 500\n",
    "\n",
    "dom_coords = np.array([[-3, -3],\n",
    "                       [3,  3]])\n",
    "\n",
    "u_train_list = []\n",
    "y_train_list = []\n",
    "s_train_list = []\n",
    "\n",
    "u_r_train_list = []\n",
    "y_r_train_list = []\n",
    "s_r_train_list = []\n",
    "\n",
    "# Random key\n",
    "key = random.PRNGKey(0)\n",
    "subkeys = random.split(key, N_train)\n",
    "\n",
    "# Create the training data \n",
    "for k in range(N_train):\n",
    "  # Create training data for bcs loss\n",
    "  u = (data[k] - mu) / sigma  # normalize data\n",
    "  u_train = np.tile(u.flatten(), (P_train, 1))  # shape = (P_train, 2 * P_train)\n",
    "\n",
    "  u_train_list.append(u_train)\n",
    "  y_train_list.append(u)\n",
    "  s_train_list.append(np.zeros((P_train, 1)))\n",
    "\n",
    "  # crate training data for physical loss\n",
    "  u_r = np.tile(u.flatten(), (Q_train, 1))  # shape = (Q_train, 2 * P_train)\n",
    "  y_r = dom_coords.min(0) + (dom_coords.max(0) - dom_coords.min(0)) * random.uniform(subkeys[k], shape=(Q_train, 2))\n",
    "\n",
    "  u_r_train_list.append(u_r)\n",
    "  y_r_train_list.append(y_r)\n",
    "  s_r_train_list.append(np.ones((Q_train, 1)))\n",
    "\n",
    "u_train = np.vstack(u_train_list)\n",
    "y_train = np.vstack(y_train_list)\n",
    "s_train = np.vstack(s_train_list)\n",
    "\n",
    "u_r_train = np.vstack(u_r_train_list)\n",
    "y_r_train = np.vstack(y_r_train_list)\n",
    "s_r_train = np.vstack(s_r_train_list)"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3e0d9ay6he_Q"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [2 * P_train, 100, 100, 100, 100, 100]\n",
    "trunk_layers =  [2, 100, 100, 100, 100, 100]\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "BmduhGwcHHXs"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "operator_dataset = DataGenerator(u_train, y_train, s_train, batch_size)\n",
    "physics_dataset = DataGenerator(u_r_train, y_r_train, s_r_train, batch_size)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gW8Ej5Jvhf0r",
    "outputId": "ec78e3f6-abd7-4f67-bf54-473e875319f7"
   },
   "source": [
    "# Train\n",
    "model.train(operator_dataset, physics_dataset, nIter=120000)"
   ],
   "execution_count": 8,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "100%|██████████| 120000/120000 [21:18<00:00, 93.85it/s, Loss=0.05399926, loss_bcs=0.00022341269, loss_res=0.031657994] \n"
     ],
     "name": "stderr"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "uhMrQopGN__b",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "outputId": "0e9ce36c-9fc6-43d9-96d5-093c39aee6ac"
   },
   "source": [
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "plt.plot(model.loss_bcs_log, lw=2, label='bcs')\n",
    "plt.plot(model.loss_res_log, lw=2, label='res')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "xzx5lAhCKRrr"
   },
   "source": [
    "# Generate the test data\n",
    "N_test = 10\n",
    "P_test = 400\n",
    "idx = random.randint(random.PRNGKey(123456), shape=(N_test,), minval=N_train, maxval=1500)\n",
    "# idx = np.array([1194, 1113, 1307, 1010])\n",
    "data_test = data[idx]\n",
    "\n",
    "u_test_list = []\n",
    "y_test_list = []\n",
    "\n",
    "for k in range(N_test):\n",
    "  u = (data_test[k] - mu) / sigma  # shape = (64, 2)\n",
    "  u_test = np.tile(u.flatten(), (P_test**2, 1))  # shape = (10000, 128)\n",
    "\n",
    "  y1 = np.linspace(dom_coords[0,0], dom_coords[1,0], P_test)\n",
    "  y2 = np.linspace(dom_coords[0,1], dom_coords[1,1], P_test)\n",
    "  y1, y2 = np.meshgrid(y1, y2)\n",
    "  y_test = np.hstack((y1.flatten()[:, None], y2.flatten()[:, None]))  # shape = (P^2, 2)\n",
    "\n",
    "  u_test_list.append(u_test)\n",
    "  y_test_list.append(y_test)\n",
    "\n",
    "u_test = np.vstack(u_test_list)\n",
    "y_test = np.vstack(y_test_list)\n",
    "\n",
    "params = model.get_params(model.opt_state)\n",
    "s_pred = model.predict_s(params, u_test, y_test)[:,None]"
   ],
   "execution_count": 10,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "D6Nmx-GnOL3a",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 441
    },
    "outputId": "41aa19a2-497f-4b56-c8a1-d64841765d8d"
   },
   "source": [
    "# Visualizations\n",
    "# Create a uniform grid\n",
    "y1 = np.linspace(dom_coords[0,0], dom_coords[1,0], P_test)\n",
    "y2 = np.linspace(dom_coords[0,1], dom_coords[1,1], P_test)\n",
    "\n",
    "y1, y2 = np.meshgrid(y1, y2)\n",
    "y_star = np.hstack((y1.flatten()[:, None], y2.flatten()[:, None]))\n",
    "\n",
    "idxs = [0, 1, 2]\n",
    "\n",
    "fig = plt.figure(figsize=(18,6))\n",
    "for k in range(3):\n",
    "  idx = idxs[k]\n",
    "  index = np.arange(idx * P_test**2,(idx + 1) * P_test**2)\n",
    "  ref = (data_test[idx] - mu) / sigma\n",
    "\n",
    "  S_pred = griddata(y_star, s_pred[index, :].flatten(), (y1, y2), method='cubic')\n",
    "  mask = np.abs(s_pred[index, :]) < 5e-3\n",
    "  \n",
    "  Y1 = y1.flatten()[:, None][mask]\n",
    "  Y2 = y2.flatten()[:, None][mask]\n",
    "\n",
    "  plt.subplot(2,3,k+1)\n",
    "  plt.plot(ref[:,0], ref[:,1], '--', label='Exact', color='blue')\n",
    "  plt.plot(Y1, Y2, '.', markersize=4, label='Predicted', color='red')\n",
    "  plt.xlabel('$x$')\n",
    "  plt.ylabel('$y$')\n",
    "  plt.tight_layout()\n",
    "  plt.title('Input sample')\n",
    "\n",
    "  plt.subplot(2,3,k+4)\n",
    "  plt.pcolor(y1, y2, S_pred, cmap='bwr')\n",
    "  # plt.colorbar()\n",
    "  plt.title('Predicted SDF')\n",
    "  plt.clim(-2., 2.)\n",
    "  plt.xlabel('$x$')\n",
    "  plt.ylabel('$y$')\n",
    "  plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 11,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 6 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "KEVLgycynOLR"
   },
   "source": [],
   "execution_count": null,
   "outputs": []
  }
 ]
}
